package com.reportgear.report.model.script;

// $ANTLR 3.2 Sep 23, 2009 12:02:23 D:\\antlr\\ConditionExpr.g 2010-01-16 23:10:56

import java.util.HashMap;

import org.antlr.runtime.BitSet;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.Parser;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;
import org.antlr.runtime.Token;
import org.antlr.runtime.TokenStream;

public class ConditionExprParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "AND", "OR", "AND_1", "OR_1", "AND_2", "OR_2", "EQ", "NEQ", "GT", "GTEQ", "LT", "LTEQ", "LIKE", "NOTLIKE", "BELONGTO", "BooleanLiteral", "NumberLiteral", "StringLiteral", "NumberListLiteral", "UnicodeEscape", "OctalEscape", "EscapeSequence", "HexDigit", "WS", "'('", "')'"
    };
    public static final int LT=14;
    public static final int T__29=29;
    public static final int T__28=28;
    public static final int NumberLiteral=20;
    public static final int AND_1=6;
    public static final int AND_2=8;
    public static final int LTEQ=15;
    public static final int GTEQ=13;
    public static final int AND=4;
    public static final int EOF=-1;
    public static final int HexDigit=26;
    public static final int BELONGTO=18;
    public static final int StringLiteral=21;
    public static final int NOTLIKE=17;
    public static final int WS=27;
    public static final int NEQ=11;
    public static final int UnicodeEscape=23;
    public static final int OR=5;
    public static final int GT=12;
    public static final int EQ=10;
    public static final int OR_1=7;
    public static final int EscapeSequence=25;
    public static final int OctalEscape=24;
    public static final int OR_2=9;
    public static final int BooleanLiteral=19;
    public static final int NumberListLiteral=22;
    public static final int LIKE=16;

    // delegates
    // delegators


        public ConditionExprParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public ConditionExprParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        

    public String[] getTokenNames() { return ConditionExprParser.tokenNames; }
    public String getGrammarFileName() { return "D:\\antlr\\ConditionExpr.g"; }


    @SuppressWarnings("unchecked")
	HashMap memory = new HashMap();
    String regex = "^\\[(\\d+,)*(%d,(\\d+,)*\\d+|%d)\\]$";
    private String extractString(String value){
    	return value.substring(1, value.length()- 1);
    }



    // $ANTLR start "expr"
    // D:\\antlr\\ConditionExpr.g:34:1: expr returns [boolean value] : e= atom ( AND e= atom | OR e= atom | AND_1 e= atom | OR_1 e= atom | AND_2 e= atom | OR_2 e= atom )* ;
    public final boolean expr() throws RecognitionException {
        boolean value = false;

        boolean e = false;


        try {
            // D:\\antlr\\ConditionExpr.g:35:2: (e= atom ( AND e= atom | OR e= atom | AND_1 e= atom | OR_1 e= atom | AND_2 e= atom | OR_2 e= atom )* )
            // D:\\antlr\\ConditionExpr.g:36:3: e= atom ( AND e= atom | OR e= atom | AND_1 e= atom | OR_1 e= atom | AND_2 e= atom | OR_2 e= atom )*
            {
            pushFollow(FOLLOW_atom_in_expr143);
            e=atom();

            state._fsp--;

            value = e;
            // D:\\antlr\\ConditionExpr.g:37:3: ( AND e= atom | OR e= atom | AND_1 e= atom | OR_1 e= atom | AND_2 e= atom | OR_2 e= atom )*
            loop1:
            do {
                int alt1=7;
                switch ( input.LA(1) ) {
                case AND:
                    {
                    alt1=1;
                    }
                    break;
                case OR:
                    {
                    alt1=2;
                    }
                    break;
                case AND_1:
                    {
                    alt1=3;
                    }
                    break;
                case OR_1:
                    {
                    alt1=4;
                    }
                    break;
                case AND_2:
                    {
                    alt1=5;
                    }
                    break;
                case OR_2:
                    {
                    alt1=6;
                    }
                    break;

                }

                switch (alt1) {
            	case 1 :
            	    // D:\\antlr\\ConditionExpr.g:38:4: AND e= atom
            	    {
            	    match(input,AND,FOLLOW_AND_in_expr154); 
            	    pushFollow(FOLLOW_atom_in_expr158);
            	    e=atom();

            	    state._fsp--;

            	    value =(value && e);

            	    }
            	    break;
            	case 2 :
            	    // D:\\antlr\\ConditionExpr.g:40:4: OR e= atom
            	    {
            	    match(input,OR,FOLLOW_OR_in_expr169); 
            	    pushFollow(FOLLOW_atom_in_expr173);
            	    e=atom();

            	    state._fsp--;

            	    value =(value || e);

            	    }
            	    break;
            	case 3 :
            	    // D:\\antlr\\ConditionExpr.g:42:4: AND_1 e= atom
            	    {
            	    match(input,AND_1,FOLLOW_AND_1_in_expr184); 
            	    pushFollow(FOLLOW_atom_in_expr188);
            	    e=atom();

            	    state._fsp--;

            	    value =(value && e);

            	    }
            	    break;
            	case 4 :
            	    // D:\\antlr\\ConditionExpr.g:44:4: OR_1 e= atom
            	    {
            	    match(input,OR_1,FOLLOW_OR_1_in_expr199); 
            	    pushFollow(FOLLOW_atom_in_expr203);
            	    e=atom();

            	    state._fsp--;

            	    value =(value || e);

            	    }
            	    break;
            	case 5 :
            	    // D:\\antlr\\ConditionExpr.g:46:4: AND_2 e= atom
            	    {
            	    match(input,AND_2,FOLLOW_AND_2_in_expr214); 
            	    pushFollow(FOLLOW_atom_in_expr218);
            	    e=atom();

            	    state._fsp--;

            	    value =(value && e);

            	    }
            	    break;
            	case 6 :
            	    // D:\\antlr\\ConditionExpr.g:48:4: OR_2 e= atom
            	    {
            	    match(input,OR_2,FOLLOW_OR_2_in_expr229); 
            	    pushFollow(FOLLOW_atom_in_expr233);
            	    e=atom();

            	    state._fsp--;

            	    value =(value || e);

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "expr"


    // $ANTLR start "atom"
    // D:\\antlr\\ConditionExpr.g:52:1: atom returns [boolean value] : ( BooleanLiteral | '(' equate ')' | '(' expr ')' );
    public final boolean atom() throws RecognitionException {
        boolean value = false;

        Token BooleanLiteral1=null;
        boolean equate2 = false;

        boolean expr3 = false;


        try {
            // D:\\antlr\\ConditionExpr.g:53:2: ( BooleanLiteral | '(' equate ')' | '(' expr ')' )
            int alt2=3;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==BooleanLiteral) ) {
                alt2=1;
            }
            else if ( (LA2_0==28) ) {
                int LA2_2 = input.LA(2);

                if ( ((LA2_2>=NumberLiteral && LA2_2<=StringLiteral)) ) {
                    alt2=2;
                }
                else if ( (LA2_2==BooleanLiteral||LA2_2==28) ) {
                    alt2=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 2, 2, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // D:\\antlr\\ConditionExpr.g:53:4: BooleanLiteral
                    {
                    BooleanLiteral1=(Token)match(input,BooleanLiteral,FOLLOW_BooleanLiteral_in_atom255); 
                    value = Boolean.parseBoolean((BooleanLiteral1!=null?BooleanLiteral1.getText():null));

                    }
                    break;
                case 2 :
                    // D:\\antlr\\ConditionExpr.g:54:4: '(' equate ')'
                    {
                    match(input,28,FOLLOW_28_in_atom262); 
                    pushFollow(FOLLOW_equate_in_atom264);
                    equate2=equate();

                    state._fsp--;

                    match(input,29,FOLLOW_29_in_atom266); 
                    value = equate2;

                    }
                    break;
                case 3 :
                    // D:\\antlr\\ConditionExpr.g:55:4: '(' expr ')'
                    {
                    match(input,28,FOLLOW_28_in_atom273); 
                    pushFollow(FOLLOW_expr_in_atom275);
                    expr3=expr();

                    state._fsp--;

                    match(input,29,FOLLOW_29_in_atom277); 
                    value = expr3;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "atom"


    // $ANTLR start "calNumber"
    // D:\\antlr\\ConditionExpr.g:58:1: calNumber returns [double value] : NumberLiteral ;
    public final double calNumber() throws RecognitionException {
        double value = 0.0;

        Token NumberLiteral4=null;

        try {
            // D:\\antlr\\ConditionExpr.g:59:2: ( NumberLiteral )
            // D:\\antlr\\ConditionExpr.g:59:4: NumberLiteral
            {
            NumberLiteral4=(Token)match(input,NumberLiteral,FOLLOW_NumberLiteral_in_calNumber295); 
            value = Double.parseDouble((NumberLiteral4!=null?NumberLiteral4.getText():null));

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "calNumber"


    // $ANTLR start "calString"
    // D:\\antlr\\ConditionExpr.g:62:1: calString returns [String value] : StringLiteral ;
    public final String calString() throws RecognitionException {
        String value = null;

        Token StringLiteral5=null;

        try {
            // D:\\antlr\\ConditionExpr.g:63:10: ( StringLiteral )
            // D:\\antlr\\ConditionExpr.g:63:17: StringLiteral
            {
            StringLiteral5=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_calString325); 
            value = (StringLiteral5!=null?StringLiteral5.getText():null);

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "calString"


    // $ANTLR start "calNumList"
    // D:\\antlr\\ConditionExpr.g:66:1: calNumList returns [String value] : NumberListLiteral ;
    public final String calNumList() throws RecognitionException {
        String value = null;

        Token NumberListLiteral6=null;

        try {
            // D:\\antlr\\ConditionExpr.g:67:2: ( NumberListLiteral )
            // D:\\antlr\\ConditionExpr.g:67:4: NumberListLiteral
            {
            NumberListLiteral6=(Token)match(input,NumberListLiteral,FOLLOW_NumberListLiteral_in_calNumList358); 
            value = (NumberListLiteral6!=null?NumberListLiteral6.getText():null);

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "calNumList"


    // $ANTLR start "equate"
    // D:\\antlr\\ConditionExpr.g:70:1: equate returns [boolean value] : ( equate_number | equate_string | equate_numlist );
    public final boolean equate() throws RecognitionException {
        boolean value = false;

        boolean equate_number7 = false;

        boolean equate_string8 = false;

        boolean equate_numlist9 = false;


        try {
            // D:\\antlr\\ConditionExpr.g:71:2: ( equate_number | equate_string | equate_numlist )
            int alt3=3;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==NumberLiteral) ) {
                int LA3_1 = input.LA(2);

                if ( ((LA3_1>=EQ && LA3_1<=LTEQ)) ) {
                    alt3=1;
                }
                else if ( (LA3_1==BELONGTO) ) {
                    alt3=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 3, 1, input);

                    throw nvae;
                }
            }
            else if ( (LA3_0==StringLiteral) ) {
                alt3=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // D:\\antlr\\ConditionExpr.g:71:4: equate_number
                    {
                    pushFollow(FOLLOW_equate_number_in_equate384);
                    equate_number7=equate_number();

                    state._fsp--;

                    value =equate_number7;

                    }
                    break;
                case 2 :
                    // D:\\antlr\\ConditionExpr.g:72:4: equate_string
                    {
                    pushFollow(FOLLOW_equate_string_in_equate391);
                    equate_string8=equate_string();

                    state._fsp--;

                    value =equate_string8;

                    }
                    break;
                case 3 :
                    // D:\\antlr\\ConditionExpr.g:73:4: equate_numlist
                    {
                    pushFollow(FOLLOW_equate_numlist_in_equate398);
                    equate_numlist9=equate_numlist();

                    state._fsp--;

                    value =equate_numlist9;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "equate"


    // $ANTLR start "equate_number"
    // D:\\antlr\\ConditionExpr.g:76:1: equate_number returns [boolean value] : (e1= calNumber EQ e2= calNumber | e1= calNumber NEQ e2= calNumber | e1= calNumber GT e2= calNumber | e1= calNumber GTEQ e2= calNumber | e1= calNumber LT e2= calNumber | e1= calNumber LTEQ e2= calNumber );
    public final boolean equate_number() throws RecognitionException {
        boolean value = false;

        double e1 = 0.0;

        double e2 = 0.0;


        try {
            // D:\\antlr\\ConditionExpr.g:77:2: (e1= calNumber EQ e2= calNumber | e1= calNumber NEQ e2= calNumber | e1= calNumber GT e2= calNumber | e1= calNumber GTEQ e2= calNumber | e1= calNumber LT e2= calNumber | e1= calNumber LTEQ e2= calNumber )
            int alt4=6;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==NumberLiteral) ) {
                switch ( input.LA(2) ) {
                case LT:
                    {
                    alt4=5;
                    }
                    break;
                case GT:
                    {
                    alt4=3;
                    }
                    break;
                case GTEQ:
                    {
                    alt4=4;
                    }
                    break;
                case EQ:
                    {
                    alt4=1;
                    }
                    break;
                case LTEQ:
                    {
                    alt4=6;
                    }
                    break;
                case NEQ:
                    {
                    alt4=2;
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 4, 1, input);

                    throw nvae;
                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // D:\\antlr\\ConditionExpr.g:77:4: e1= calNumber EQ e2= calNumber
                    {
                    pushFollow(FOLLOW_calNumber_in_equate_number418);
                    e1=calNumber();

                    state._fsp--;

                    match(input,EQ,FOLLOW_EQ_in_equate_number420); 
                    pushFollow(FOLLOW_calNumber_in_equate_number424);
                    e2=calNumber();

                    state._fsp--;


                    					if(e1 == e2){
                    						value =true;
                    					}else{
                    						value =false;
                    					} 
                    				      

                    }
                    break;
                case 2 :
                    // D:\\antlr\\ConditionExpr.g:84:4: e1= calNumber NEQ e2= calNumber
                    {
                    pushFollow(FOLLOW_calNumber_in_equate_number433);
                    e1=calNumber();

                    state._fsp--;

                    match(input,NEQ,FOLLOW_NEQ_in_equate_number435); 
                    pushFollow(FOLLOW_calNumber_in_equate_number439);
                    e2=calNumber();

                    state._fsp--;


                    					if(e1 == e2){
                    						value =false;
                    					}else{
                    						value =true;
                    					} 
                    				      

                    }
                    break;
                case 3 :
                    // D:\\antlr\\ConditionExpr.g:91:4: e1= calNumber GT e2= calNumber
                    {
                    pushFollow(FOLLOW_calNumber_in_equate_number448);
                    e1=calNumber();

                    state._fsp--;

                    match(input,GT,FOLLOW_GT_in_equate_number450); 
                    pushFollow(FOLLOW_calNumber_in_equate_number454);
                    e2=calNumber();

                    state._fsp--;


                    					if(e1 > e2){
                    						value =true;
                    					}else{
                    						value =false;
                    					} 
                    				      

                    }
                    break;
                case 4 :
                    // D:\\antlr\\ConditionExpr.g:98:3: e1= calNumber GTEQ e2= calNumber
                    {
                    pushFollow(FOLLOW_calNumber_in_equate_number462);
                    e1=calNumber();

                    state._fsp--;

                    match(input,GTEQ,FOLLOW_GTEQ_in_equate_number464); 
                    pushFollow(FOLLOW_calNumber_in_equate_number468);
                    e2=calNumber();

                    state._fsp--;


                    					if(e1 >= e2){
                    						value =true;
                    					}else{
                    						value =false;
                    					} 
                    				      

                    }
                    break;
                case 5 :
                    // D:\\antlr\\ConditionExpr.g:105:3: e1= calNumber LT e2= calNumber
                    {
                    pushFollow(FOLLOW_calNumber_in_equate_number476);
                    e1=calNumber();

                    state._fsp--;

                    match(input,LT,FOLLOW_LT_in_equate_number478); 
                    pushFollow(FOLLOW_calNumber_in_equate_number482);
                    e2=calNumber();

                    state._fsp--;


                    					if(e1 < e2){
                    						value =true;
                    					}else{
                    						value =false;
                    					} 
                    				      

                    }
                    break;
                case 6 :
                    // D:\\antlr\\ConditionExpr.g:112:3: e1= calNumber LTEQ e2= calNumber
                    {
                    pushFollow(FOLLOW_calNumber_in_equate_number490);
                    e1=calNumber();

                    state._fsp--;

                    match(input,LTEQ,FOLLOW_LTEQ_in_equate_number492); 
                    pushFollow(FOLLOW_calNumber_in_equate_number496);
                    e2=calNumber();

                    state._fsp--;


                    					if(e1 <= e2){
                    						value =true;
                    					}else{
                    						value =false;
                    					} 
                    				      

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "equate_number"


    // $ANTLR start "equate_string"
    // D:\\antlr\\ConditionExpr.g:122:1: equate_string returns [boolean value] : (e1= calString EQ e2= calString | e1= calString NEQ e2= calString | e1= calString LIKE e2= calString | e1= calString NOTLIKE e2= calString );
    public final boolean equate_string() throws RecognitionException {
        boolean value = false;

        String e1 = null;

        String e2 = null;


        try {
            // D:\\antlr\\ConditionExpr.g:123:2: (e1= calString EQ e2= calString | e1= calString NEQ e2= calString | e1= calString LIKE e2= calString | e1= calString NOTLIKE e2= calString )
            int alt5=4;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==StringLiteral) ) {
                switch ( input.LA(2) ) {
                case LIKE:
                    {
                    alt5=3;
                    }
                    break;
                case NOTLIKE:
                    {
                    alt5=4;
                    }
                    break;
                case NEQ:
                    {
                    alt5=2;
                    }
                    break;
                case EQ:
                    {
                    alt5=1;
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 5, 1, input);

                    throw nvae;
                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // D:\\antlr\\ConditionExpr.g:123:3: e1= calString EQ e2= calString
                    {
                    pushFollow(FOLLOW_calString_in_equate_string516);
                    e1=calString();

                    state._fsp--;

                    match(input,EQ,FOLLOW_EQ_in_equate_string518); 
                    pushFollow(FOLLOW_calString_in_equate_string522);
                    e2=calString();

                    state._fsp--;


                    					if(e1.equals(e2)){
                    					 	value =true;
                    					}else{
                    						value =false;
                    					}
                    				    

                    }
                    break;
                case 2 :
                    // D:\\antlr\\ConditionExpr.g:130:3: e1= calString NEQ e2= calString
                    {
                    pushFollow(FOLLOW_calString_in_equate_string530);
                    e1=calString();

                    state._fsp--;

                    match(input,NEQ,FOLLOW_NEQ_in_equate_string532); 
                    pushFollow(FOLLOW_calString_in_equate_string536);
                    e2=calString();

                    state._fsp--;


                    					if(e1.equals(e2)){
                    					 	value =false;
                    					}else{
                    						value =true;
                    					}
                    				    

                    }
                    break;
                case 3 :
                    // D:\\antlr\\ConditionExpr.g:137:3: e1= calString LIKE e2= calString
                    {
                    pushFollow(FOLLOW_calString_in_equate_string544);
                    e1=calString();

                    state._fsp--;

                    match(input,LIKE,FOLLOW_LIKE_in_equate_string546); 
                    pushFollow(FOLLOW_calString_in_equate_string550);
                    e2=calString();

                    state._fsp--;


                    					String v1 = extractString(e1);
                    					String v2 = extractString(e2);
                    					if(v1.indexOf(v2) >= 0){
                    					 	value =true;
                    					}else{
                    						value =false;
                    					}
                    				    

                    }
                    break;
                case 4 :
                    // D:\\antlr\\ConditionExpr.g:146:3: e1= calString NOTLIKE e2= calString
                    {
                    pushFollow(FOLLOW_calString_in_equate_string558);
                    e1=calString();

                    state._fsp--;

                    match(input,NOTLIKE,FOLLOW_NOTLIKE_in_equate_string560); 
                    pushFollow(FOLLOW_calString_in_equate_string564);
                    e2=calString();

                    state._fsp--;


                    					String v1 = extractString(e1);
                    					String v2 = extractString(e2);
                    					if(v1.indexOf(v2)== -1){
                    					 	value =true;
                    					}else{
                    						value =false;
                    					}
                    				    

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "equate_string"


    // $ANTLR start "equate_numlist"
    // D:\\antlr\\ConditionExpr.g:157:1: equate_numlist returns [boolean value] : e1= calNumber BELONGTO e2= calNumList ;
    public final boolean equate_numlist() throws RecognitionException {
        boolean value = false;

        double e1 = 0.0;

        String e2 = null;


        try {
            // D:\\antlr\\ConditionExpr.g:158:2: (e1= calNumber BELONGTO e2= calNumList )
            // D:\\antlr\\ConditionExpr.g:158:3: e1= calNumber BELONGTO e2= calNumList
            {
            pushFollow(FOLLOW_calNumber_in_equate_numlist583);
            e1=calNumber();

            state._fsp--;

            match(input,BELONGTO,FOLLOW_BELONGTO_in_equate_numlist585); 
            pushFollow(FOLLOW_calNumList_in_equate_numlist589);
            e2=calNumList();

            state._fsp--;


            					int v = (int)e1;
            					String r = String.format(regex,v,v); 
            					value = e2.matches(r);
            				      

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "equate_numlist"

    // Delegated rules


 

    public static final BitSet FOLLOW_atom_in_expr143 = new BitSet(new long[]{0x00000000000003F2L});
    public static final BitSet FOLLOW_AND_in_expr154 = new BitSet(new long[]{0x0000000010080000L});
    public static final BitSet FOLLOW_atom_in_expr158 = new BitSet(new long[]{0x00000000000003F2L});
    public static final BitSet FOLLOW_OR_in_expr169 = new BitSet(new long[]{0x0000000010080000L});
    public static final BitSet FOLLOW_atom_in_expr173 = new BitSet(new long[]{0x00000000000003F2L});
    public static final BitSet FOLLOW_AND_1_in_expr184 = new BitSet(new long[]{0x0000000010080000L});
    public static final BitSet FOLLOW_atom_in_expr188 = new BitSet(new long[]{0x00000000000003F2L});
    public static final BitSet FOLLOW_OR_1_in_expr199 = new BitSet(new long[]{0x0000000010080000L});
    public static final BitSet FOLLOW_atom_in_expr203 = new BitSet(new long[]{0x00000000000003F2L});
    public static final BitSet FOLLOW_AND_2_in_expr214 = new BitSet(new long[]{0x0000000010080000L});
    public static final BitSet FOLLOW_atom_in_expr218 = new BitSet(new long[]{0x00000000000003F2L});
    public static final BitSet FOLLOW_OR_2_in_expr229 = new BitSet(new long[]{0x0000000010080000L});
    public static final BitSet FOLLOW_atom_in_expr233 = new BitSet(new long[]{0x00000000000003F2L});
    public static final BitSet FOLLOW_BooleanLiteral_in_atom255 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_28_in_atom262 = new BitSet(new long[]{0x0000000000300000L});
    public static final BitSet FOLLOW_equate_in_atom264 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_29_in_atom266 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_28_in_atom273 = new BitSet(new long[]{0x0000000010080000L});
    public static final BitSet FOLLOW_expr_in_atom275 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_29_in_atom277 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NumberLiteral_in_calNumber295 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_StringLiteral_in_calString325 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NumberListLiteral_in_calNumList358 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_equate_number_in_equate384 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_equate_string_in_equate391 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_equate_numlist_in_equate398 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calNumber_in_equate_number418 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_EQ_in_equate_number420 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_calNumber_in_equate_number424 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calNumber_in_equate_number433 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_NEQ_in_equate_number435 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_calNumber_in_equate_number439 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calNumber_in_equate_number448 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_GT_in_equate_number450 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_calNumber_in_equate_number454 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calNumber_in_equate_number462 = new BitSet(new long[]{0x0000000000002000L});
    public static final BitSet FOLLOW_GTEQ_in_equate_number464 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_calNumber_in_equate_number468 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calNumber_in_equate_number476 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_LT_in_equate_number478 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_calNumber_in_equate_number482 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calNumber_in_equate_number490 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_LTEQ_in_equate_number492 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_calNumber_in_equate_number496 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calString_in_equate_string516 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_EQ_in_equate_string518 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_calString_in_equate_string522 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calString_in_equate_string530 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_NEQ_in_equate_string532 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_calString_in_equate_string536 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calString_in_equate_string544 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_LIKE_in_equate_string546 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_calString_in_equate_string550 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calString_in_equate_string558 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_NOTLIKE_in_equate_string560 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_calString_in_equate_string564 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_calNumber_in_equate_numlist583 = new BitSet(new long[]{0x0000000000040000L});
    public static final BitSet FOLLOW_BELONGTO_in_equate_numlist585 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_calNumList_in_equate_numlist589 = new BitSet(new long[]{0x0000000000000002L});

}